home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / m68k / 68343ffp.arc / IEFFRONT.SA < prev    next >
Text File  |  1989-08-30  |  16KB  |  294 lines
  1.          TTL       IEEE FORMAT FRONT-END ROUTINES (IEFFRONT)
  2. IEFFRONT IDNT   1,1  IEEE FORMAT EQUIVALENT FRONT-END ROUTINES
  3. ******************************************
  4. *  (C)  COPYRIGHT 1981 BY MOTOROLA INC.  *
  5. ******************************************
  6.  
  7. *******************************************************
  8. *               IDFSOP (INTERNAL SUBROUTINE)          *
  9. *     IEEE FORMAT EQUIVALENT PROCESS SINGLE OPERAND   *
  10. *                                                     *
  11. *  INPUT:   D7 - IEEE FORMAT NUMBER ARGUMENT2         *
  12. *           SP -> +0 RETURN ADDRESS TO CALLER         *
  13. *                 +4 ORIGINAL CALLER'S RETURN ADDRESS *
  14. *                                                     *
  15. *  OUTPUT:  D6 CONVERTED TO FAST FLOATING POINT       *
  16. *           FORMAT WITH USER'S ORIGINAL REGISTERS     *
  17. *           D3-D7 STACKED OR A DIRECT RETURN BYPASSING*
  18. *           THE FIRST-LINE ROUTINE IF EITHER          *
  19. *           PARAMETER WAS A NAN                       *
  20. *                                                     *
  21. *                                                     *
  22. *     RETURN IS VIA VECTORED BRANCH WITH OFFSET ADDED *
  23. *     TO THE ADDRESS ON THE STACK.  THIS ALLOWS EASY  *
  24. *     TYPE DESCRIMINATION BY THE CALLER FOR SELECTED  *
  25. *     DATA TYPES:                                     *
  26. *                                                     *
  27. *   RETURN  +0   IF THE ARGUMENT IS NORMALIZED        *
  28. *                (INCLUDING ZERO AND DENORMALIZED)    *
  29. *           +2   IF ARGUMENT IS AN INFINITY           *
  30. *                                                     *
  31. *   THE STACK APPEARS:  S+0  ORIGINAL D3-D7 UPON ENTRY*
  32. *                       S+20 ORIGINAL CALLER'S RETURN *
  33. *                                                     *
  34. *  CONDITION CODES:                                   *
  35. *                                                     *
  36. *       (ONLY IF BYPASSED RETURN DONE)                *
  37. *                                                     *
  38. *            N - UNDEFINED                            *
  39. *            Z - CLEARED                              *
  40. *            V - SET (RESULT IS A NAN)                *
  41. *            C - UNDEFINED                            *
  42. *            X - UNDEFINED                            *
  43. *                                                     *
  44. *       (ONLY IF RETURN TO IMMEDIATE CALLER)          *
  45. *                                                     *
  46. *            N - SET IF VALUE IS NEGATIVE             *
  47. *            Z - SET IF VALUE IS A ZERO               *
  48. *            V - UNDEINFED                            *
  49. *            C - UNDEFINED                            *
  50. *            X - UNDEFINED                            *
  51. *                                                     *
  52. *  THIS ROUTINE IS A FRONT END FOR THE IEEE FORMAT    *
  53. *  CAPATIBLE ROUTINES (IEF ROUTINES).  IT MAY         *
  54. *  BYPASS THE CALLER TO DIRECTLY RETURN TO THE USER   *
  55. *  CODE IF THE ARGUMENT IS A NAN (NOT-A-NUMBER)       *
  56. *  SINCE THE RESULT MUST BE A NAN (THE SAME).         *
  57. *  THE CALL TO THIS ROUTINE MUST BE THE               *
  58. *  FIRST INSTRUCTION OF THE LEVEL-1 IEF ROUTINE,      *
  59. *  SINCE IT MAY RETURN DIRECTLY TO THE ORIGINAL       *
  60. *  CALLER.  ALSO REGISTERS MUST BE UNALTERED BEFORE   *
  61. *  THE CALL.                                          *
  62. *                                                     *
  63. *  LOGIC:  THE FOLLOWING DECISION TREE SHOWS THE      *
  64. *          PROCESSING FOR THIS ROUTINE AND WHAT       *
  65. *          VALUES ARE RETURNED FOR THE ARGUMENT       *
  66. *                                                     *
  67. *   IF ARG IS NAN THEN                                *
  68. *         SET THE "V" BIT IN THE CCR AND BYPASS THE   *
  69. *         CALLER RETURNING WITH ARG (D7) UNCHANGED    *
  70. *                                                     *
  71. *   IF ARG IS AN INFINITY THEN ADJUST RETURN ADDRESS  *
  72. *         AND RETURN WITH CCR SET FOR PLUS OR MINUS   *
  73. *         AT OFFSET +2                                *
  74. *                                                     *
  75. *   IF ARG IS DENORMALIZED THEN SET IT TO ZERO        *
  76. *        ELSE IT IS NORMALIZED - CONVERT TO FFP FORMAT*
  77. *                                                     *
  78. *   RETURN TO CALLER AT +0 OFFSET                     *
  79. *                                                     *
  80. *  NOTES:                                             *
  81. *  1) DURING THE CONVERSION OF NORMALIZED IEEE FORMAT *
  82. *     NUMBERS TO FFP FORMAT, THE EXPONENT MAY BE TOO  *
  83. *     LARGE FOR FFP MAGNITUDES.  WHEN THIS IS TRUE    *
  84. *     THEN THE VALUE IS CONVERTED TO AN INFINITY WITH *
  85. *     THE PROPER SIGN.  IF THE EXPONENT IS TOO SMALL  *
  86. *     THAN A ZERO IS RETURNED.  SEE THE MC68344 USER'S*
  87. *     GUIDE FOR COMPLETE DETAILS OF THE RANGE HANDLING*
  88. *     OF THE FAST FLOATING POINT FORMAT CONVERSION.   *
  89. *  2) ALL ZEROES ARE TREATED AS POSITIVE VALUES.      *
  90. *  3) DENORMALIZED VALUES ARE TREATED AS ZEROES.      *
  91. *                                                     *
  92. *******************************************************
  93.  
  94.          SECTION   9
  95.  
  96.          XDEF      IEFSOP    SINGLE OPERAND CONVERT
  97.  
  98. EXPMSK   EQU       $7F800000 IEEE FORMAT EXPONENT MASK
  99. VBIT     EQU       $0002     CONDITION CODE "V" BIT MASK
  100. CBIT     EQU       $0001     CONDITION CODE "C" BIT MASK
  101.  
  102. * CALL INTERNAL SUBROUTINE TO PARSE ARGUMENT (D7)
  103. IEFSOP   LEA       -16(SP),SP ADJUST STACK FOR NEW RETURN ADDRESS POSITION
  104.          MOVE.L    16(SP),-(SP) MOVE RETURN ADDRESS TO NEW LOCATION
  105.          MOVEM.L   D3-D7,4(SP) SAVE ORIGINAL CALLER'S REGISTERS
  106.          BSR.S     IEFPRSE   CONVERT ARGUMENT TWO
  107.          BCC.S     IEFARGS   BRANCH NOT INFINITY
  108.          MOVE.W    CCR,D5    SAVE CCR
  109.          ADD.L     #2,(SP)   ADJUST RETURN ADDRESS
  110.          MOVE.W    D5,CCR    RESTORE CCR
  111. IEFARGS  RTS                 RETURN TO CALLER AT PROPER OFFSET
  112.          PAGE
  113. *******************************************************
  114. *               IDFDOP (INTERNAL SUBROUTINE)          *
  115. *     IEEE FORMAT EQUIVALENT PROCESS DOUBLE OPERAND   *
  116. *                                                     *
  117. *  INPUT:   D6 - IEEE FORMAT NUMBER ARGUMENT1         *
  118. *           D7 - IEEE FORMAT NUMBER ARGUMENT2         *
  119. *           SP -> +0 RETURN ADDRESS TO CALLER         *
  120. *                 +4 ORIGINAL CALLER'S RETURN ADDRESS *
  121. *                                                     *
  122. *  OUTPUT:  D6/D7 CONVERTED TO FAST FLOATING POINT    *
  123. *           FORMAT WITH USER'S ORIGINAL REGISTERS     *
  124. *           D3-D7 STACKED OR A DIRECT RETURN BYPASSING*
  125. *           THE FIRST-LINE ROUTINE IF EITHER          *
  126. *           PARAMETER WAS A NAN                       *
  127. *                                                     *
  128. *                                                     *
  129. *     RETURN IS VIA VECTORED BRANCH WITH OFFSET ADDED *
  130. *     TO THE ADDRESS ON THE STACK.  THIS ALLOWS EASY  *
  131. *     TYPE DESCRIMINATION BY THE CALLER FOR SELECTED  *
  132. *     DATA TYPES:                                     *
  133. *                                                     *
  134. *   RETURN  +0   IF BOTH ARGUMENTS NORMALIZED         *
  135. *                (INCLUDING ZERO AND DENORMALIZED)    *
  136. *           +2   IF ARG2 IS AN INFINITY               *
  137. *           +4   IF ARG1 IS AN INFINITY               *
  138. *           +6   IF BOTH ARGUMENTS ARE INFINITIES     *
  139. *                                                     *
  140. *   THE STACK APPEARS:  S+0  ORIGINAL D3-D7 UPON ENTRY*
  141. *                       S+20 ORIGINAL CALLER'S RETURN *
  142. *                                                     *
  143. *  CONDITION CODES:                                   *
  144. *                                                     *
  145. *      (ONLY IF BYPASSED RETURN DONE)                 *
  146. *                                                     *
  147. *            N - UNDEFINED                            *
  148. *            Z - CLEARED                              *
  149. *            V - SET (RESULT IS A NAN)                *
  150. *            C - UNDEFINED                            *
  151. *            X - UNDEFINED                            *
  152. *                                                     *
  153. *      (ONLY IF RETURN DIRECTLY TO IMMEDIATE CALLER)  *
  154. *                                                     *
  155. *            N - SET IF ARG1 IS NEGATIVE              *
  156. *            Z - SET IF ARG1 IS ZERO                  *
  157. *            V - UNDEFINED                            *
  158. *            C - SET IF ARG1 IS AN INFINITY           *
  159. *            X - UNDEFINED                            *
  160. *                                                     *
  161. *  THIS ROUTINE IS A FRONT END FOR THE IEEE FORMAT    *
  162. *  CAPATIBLE ROUTINES (IEF ROUTINES).  IT MAY         *
  163. *  BYPASS THE CALLER TO DIRECTLY RETURN TO THE USER   *
  164. *  CODE IF AN ARGUMENT IS A NAN (NOT-A-NUMBER)        *
  165. *  SINCE THE RESULT MUST BE A NAN.  IT MUST BE THE    *
  166. *  FIRST INSTRUCTION OF THE LEVEL-1 IEF ROUTINE,      *
  167. *  SINCE IT MAY RETURN DIRECTLY TO THE ORIGINAL       *
  168. *  CALLER.  ALSO REGISTERS MUST BE UNALTERED BEFORE   *
  169. *  THE CALL.                                          *
  170. *                                                     *
  171. *  LOGIC:  THE FOLLOWING DECISION TREE SHOWS THE      *
  172. *          PROCESSING FOR THIS ROUTINE AND WHAT       *
  173. *          VALUES ARE RETURNED FOR ARG1 AND ARG2      *
  174. *                                                     *
  175. *   IF ARG2 IS NAN THEN                               *
  176. *         SET THE "V" BIT IN THE CCR AND BYPASS THE   *
  177. *         CALLER RETURNING WITH ARG2 (D7) UNCHANGED   *
  178. *                                                     *
  179. *   IF ARG1 IS NAN THEN                               *
  180. *         SET THE "V" BIT IN THE CCR AND BYPASS THE   *
  181. *         CALLER RETURNING WITH ARG1 COPIED TO ARG2   *
  182. *                                                     *
  183. *   IF ARG2 IS AN INFINITY THEN ADJUST RETURN ADDRESS *
  184. *                                                     *
  185. *   IF ARG1 IS AN INFINITY THEN ADJUST RETURN ADDRESS *
  186. *                                                     *
  187. *   IF ARG2 IS DENORMALIZED THEN SET IT TO ZERO       *
  188. *        ELSE IT IS NORMALIZED - CONVERT TO FFP FORMAT*
  189. *                                                     *
  190. *   IF ARG1 IS DENORMALIZED THEN SET IT TO ZERO       *
  191. *        ELSE IT IS NORMALIZED - CONVERT TO FFP FORMAT*
  192. *                                                     *
  193. *   RETURN TO CALLER AT PROPER OFFSET                 *
  194. *                                                     *
  195. *  NOTES:                                             *
  196. *  1) DURING THE CONVERSION OF NORMALIZED IEEE FORMAT *
  197. *     NUMBERS TO FFP FORMAT, THE EXPONENT MAY BE TOO  *
  198. *     LARGE FOR FFP MAGNITUDES.  WHEN THIS IS TRUE    *
  199. *     THEN THE VALUE IS CONVERTED TO AN INFINITY WITH *
  200. *     THE PROPER SIGN.  IF THE EXPONENT IS TOO SMALL  *
  201. *     THAN A ZERO IS RETURNED.  SEE THE MC68344 USER'S*
  202. *     GUIDE FOR COMPLETE DETAILS OF THE RANGE         *
  203. *     TREATMENT BY THE FAST FLOATING POINT CONVERSION.*
  204. *  2) ALL ZEROES ARE TREATED AS POSITIVE VALUES.      *
  205. *  3) DENORMALIZED VALUES ARE TREATED AS ZEROES.      *
  206. *                                                     *
  207. *******************************************************
  208.  
  209.          SECTION   9
  210.  
  211.          XDEF      IEFDOP    DUAL OPERAND CONVERT
  212.  
  213. * CALL INTERNAL SUBROUTINE TO PARSE ARGUMENT 2 (D7)
  214. IEFDOP   LEA       -16(SP),SP RESET STACK FOR REGISTER STORAGE
  215.          MOVE.L    16(SP),-(SP) MOVE RETURN ADDRESS TO NEW BOTTOM OF STACK
  216.          MOVEM.L   D3-D7,4(SP) SAVE ORIGINAL REGISTERS ABOVE RETURN ADDRESS
  217.          BSR.S     IEFPRSE   CONVERT ARGUMENT TWO
  218.          BCC.S     IEFARG2   BRANCH NOT INFINITY
  219.          ADD.L     #2,(SP)   ADJUST RETURN ADDRESS
  220. IEFARG2  EXG.L     D6,D7     SWAP ARGUMENTS TO CONVERT ARG1 (NAN RETURNS ARG1)
  221.          BSR.S     IEFPRSE   CONVERT SECOND ARGUMENT
  222.          BCC.S     IEFNOTI   BRANCH NOT INFINITY
  223.          MOVE.W    CCR,D5    SAVE CCR
  224.          ADD.L     #4,(SP)   ADJUST RETURN ADDRESS
  225.          MOVE.W    D5,CCR    RESTORE CCR
  226. IEFNOTI  EXG.L     D6,D7     SWAP ARGUMENTS BACK INTO PLACE
  227.          RTS                 RETURN TO CALLER
  228.          PAGE
  229. *
  230. * INTERNAL CONVERT SUBROUTINE
  231. *   CONVERT THE ARGUMENT IN D7 TO FAST FLOATING POINT FORMAT AND RETURN
  232. *   CCR SET FOR TEST AGAINST SIGN AND ZERO
  233. *
  234. * OUTPUT:
  235. *         IF NAN - DIRECT RETURN BYPASSING CALLER WITH NAN IN D7 AND "V" SET
  236. *           ELSE RETURN WITH CONVERTED VALUE AND "C" BIT IF IS AN INFNITY
  237. *
  238. IEFPRSE  MOVE.L    D7,D5     SAVE ORIGINAL ARGUMENT
  239.          SWAP.W    D7        SWAP WORD HALVES
  240.          ROR.L     #7,D7     EXPONENT TO LOW BYTE
  241.          EOR.B     #$80,D7     CONVERT FROM EXCESS 127 TO TWO'S-COMPLEMENT
  242.          ADD.B     D7,D7     FROM 8 TO 7 BIT EXPONENT
  243.          BVS.S     IEFOVF    BRANCH WILL NOT FIT
  244.          ADD.B     #2<<1+1,D7 ADJUST EXCESS 127 TO 64 AND SET MANTISSA HIGH BIT
  245.          BVS.S     IEFEXH    BRANCH EXPONENT TOO LARGE (OVERFLOW)
  246.          EOR.B     #$80,D7     BACK TO EXCESS 64
  247.          ROR.L     #1,D7     TO FAST FLOAT REPRESENTATION
  248.          TST.B     D7        CLEAR CARRY
  249.          RTS                 RETURN TO CALLER
  250.  
  251. * OVERFLOW DETECTED - CAUSED BY ONE OF THE FOLLOWING:
  252. *        - FALSE EXPONENT OVERFLOW DUE TO DIFFERENCE IN EXCESS NOTATIONS
  253. *        - EXPONENT TOO HIGH OR LOW TO FIT IN 7 BITS (EXPONENT OVER/UNDERFLOW)
  254. *        - AN EXPONENT OF $FF REPRESENTING AN INFINITY
  255. *        - AN EXPONENT OF $00 REPRESENTING A ZERO, NAN, OR DENORMALIZED VALUE
  256. IEFOVF   BCC.S     IEFOVLW   BRANCH IF OVERFLOW (EXPONENT $FF OR TOO LARGE)
  257. * CHECK FOR FALSE OVERFLOW
  258.          CMP.B     #$7C,D7   ? WILL CORRECTED VALUE BE OK
  259.          BEQ.S     IEFFOV    YES, BRANCH IF FALSE OVERFLOW
  260.          CMP.B     #$7E,D7   ? WILL CORRECTED VALUE BE IN RANGE
  261.          BNE.S     IEFNOTF   NO, BRANCH NOT FALSE OVERFLOW
  262. IEFFOV   ADD.B     #$80+2<<1+1,D7 BACK TO EXCESS 64 AND SET MANTISSA HIGH BIT
  263.          ROR.L     #1,D7     TO FAST FLOATING POINT REPRESENTATION
  264.          TST.B     D7        INSURE NOT ILLEGAL ZERO SIGN+EXPONENT BYTE
  265.          BNE.S     IEFCRT    NO, IS OK SO RETURN "C" CLEARED
  266. * EXPONENT LOW - IS ZERO, DENORMALIZED VALUE, OR TOO SMALL AN EXPONENT
  267. IEFNOTF  MOVE.L    #0,D7     RETURN ZERO FOR ALL OF THESE CASES ("C" CLEARED)
  268. IEFCRT   RTS                 RETURN TO CALLER
  269.  
  270. * EXPONENT HIGH - CHECK FOR EXPONENT TOO HIGH, INFINITY, OR NAN
  271. IEFOVLW  CMP.B     #$FE,D7   ? WAS ORIGINAL EXPONENT $FF
  272.          BNE.S     IEFEXH    NO, BRANCH EXPONENT TOO LARGE
  273.          LSR.L     #8,D7     SHIFT OUT EXPONENT
  274.          LSR.L     #1,D7     SHIFT SIGN OUT INTO "X" BIT
  275.          BEQ.S     IEFEXHI   BRANCH IF TRUE INFINITY
  276.  
  277. * ARG2 IS A NAN - BYPASS CALLER AND RETURN AS THE RESULT WITH "V" BIT SET
  278.          MOVE.L    D5,D7     RETURN ORIGINAL ARGUMENT
  279.          ADD.L     #8,SP     SKIP INTERNAL AND CALLER RETURN ADDRESSES
  280.          MOVEM.L   (SP)+,D3-D6 RETURN REGISTERS INTACT
  281.          ADD.L     #4,SP     SKIP ORIGINAL D7
  282.          OR.B      #VBIT,CCR SET V BIT ON
  283.          RTS                 RETURN TO ORIGINAL CALLER
  284.  
  285. * ARG2 IS INFINITY OR EXPONENT TOO LARGE SO FORCE TO INFINITY (SIGN IS BIT 8)
  286. IEFEXH   LSL.W     #8,D7     SET "X" CCR BIT SAME AS SIGN
  287. IEFEXHI  MOVE.L    #EXPMSK<<1,D7 SET EXPONENT ALL ONES FOR INFINITY AND OVER 1
  288.          ROXR.L    #1,D7     SHIFT SIGN AND AND FINISHED RESULT
  289.          OR.B      #CBIT,CCR SET "C" BIT ON FOR INFINITY NOTICE
  290.          RTS                 RETURN TO CONVERSION ROUTINE
  291.  
  292.          END
  293.  
  294.